home *** CD-ROM | disk | FTP | other *** search
/ All for Cell Phones: Sony Ericsson / Sony-Ericsson 2004.iso / Java / MChess / MobileChess.jar / D / I.class (.txt)
Encoding:
Java Class File  |  2002-07-18  |  10.0 KB  |  655 lines
  1. package D;
  2.  
  3. // $FF: renamed from: D.I
  4. public class class_0 {
  5.    // $FF: renamed from: I (byte, byte, byte, byte[][], boolean[][]) boolean
  6.    public static final boolean method_0(byte var0, byte var1, byte var2, byte[][] var3, boolean[][] var4) {
  7.       byte var5 = println(var0);
  8.       byte var6 = abs(var0);
  9.       byte var7 = 0;
  10.       byte var8 = 0;
  11.       byte var9 = 0;
  12.       byte[][] var10 = new byte[8][8];
  13.       byte[][] var11 = new byte[][]{{-1, 1}, {-2, 2}};
  14.       append(var3, var10);
  15.       boolean var12 = abs(var5, var6, var10, var1, var2);
  16.       byte var13 = 0;
  17.  
  18.       for(byte var14 = 0; var14 < 8 && !var12; ++var14) {
  19.          for(byte var15 = 0; var15 < 8 && !var12; ++var15) {
  20.             if (var4[var14][var15]) {
  21.                var12 = false;
  22.  
  23.                for(byte var16 = -1; var16 < 2 && !var12; ++var16) {
  24.                   for(byte var17 = -1; var17 < 2 && !var12; ++var17) {
  25.                      if (var16 != 0 || var17 != 0) {
  26.                         int var18 = abs(method_11(var14, var15), var16, var17, var1, var10);
  27.                         var7 = (byte)(var18 >> 8);
  28.                         if (var7 != 0) {
  29.                            var13 = (byte)(var18 & 255);
  30.                            var8 = println(var13);
  31.                            var9 = abs(var13);
  32.                            if (method_3(var8, var9, var14, var15, var10, var0, var2, true)) {
  33.                               var12 = true;
  34.                            }
  35.                         }
  36.                      }
  37.                   }
  38.                }
  39.  
  40.                if (!var12) {
  41.                   int var25 = 0;
  42.                   int var28 = 0;
  43.  
  44.                   for(byte var19 = 0; var19 < 2 && !var12; ++var19) {
  45.                      for(byte var20 = 0; var20 < 2 && !var12; ++var20) {
  46.                         var25 = var14 + var11[0][var19];
  47.                         var28 = var15 + var11[1][var20];
  48.                         if (var25 > -1 && var25 < 8 && var28 > -1 && var28 < 8 && method_4(var3[var25][var28]) == 5 && method_6(var3[var25][var28]) == var1) {
  49.                            var12 = toString((byte)var25, (byte)var28, var14, var15, var10, var0, var2);
  50.                         }
  51.  
  52.                         if (!var12) {
  53.                            var25 = var14 + var11[1][var20];
  54.                            var28 = var15 + var11[0][var19];
  55.                            if (var25 > -1 && var25 < 8 && var28 > -1 && var28 < 8 && method_4(var3[var25][var28]) == 5 && method_6(var3[var25][var28]) == var1) {
  56.                               var12 = toString((byte)var25, (byte)var28, var14, var15, var10, var0, var2);
  57.                            }
  58.                         }
  59.                      }
  60.                   }
  61.                }
  62.             }
  63.          }
  64.       }
  65.  
  66.       return !var12;
  67.    }
  68.  
  69.    // $FF: renamed from: I (byte, byte, byte, byte[][]) boolean
  70.    public static final boolean method_1(byte var0, byte var1, byte var2, byte[][] var3) {
  71.       boolean var4 = false;
  72.       byte[][] var5 = new byte[8][8];
  73.       append(var3, var5);
  74.       byte var6 = 0;
  75.  
  76.       for(byte var7 = 0; var7 < 8 && !var4; ++var7) {
  77.          for(byte var8 = 0; var8 < 8 && !var4; ++var8) {
  78.             var6 = var5[var7][var8];
  79.             if (method_4(var6) != 0 && method_6(var6) == var1) {
  80.                switch (method_4(var6)) {
  81.                   case 1:
  82.                      var4 = abs(var7, var8, var5, var1, var2);
  83.                      break;
  84.                   case 2:
  85.                      var4 = append(var7, var8, var5, var1, var2, var0);
  86.                      break;
  87.                   case 3:
  88.                      var4 = arraycopy(var7, var8, var5, var1, var2, var0);
  89.                      break;
  90.                   case 4:
  91.                      var4 = out(var7, var8, var5, var1, var2, var0);
  92.                      break;
  93.                   case 5:
  94.                      var4 = println(var7, var8, var5, var1, var2, var0);
  95.                      break;
  96.                   case 6:
  97.                      var4 = toString(var7, var8, var5, var1, var2, var0);
  98.                }
  99.             }
  100.          }
  101.       }
  102.  
  103.       return !var4;
  104.    }
  105.  
  106.    public static final boolean abs(byte var0, byte var1, byte[][] var2, byte var3, byte var4) {
  107.       boolean var5 = false;
  108.  
  109.       for(int var6 = -1; var6 < 2 && !var5; ++var6) {
  110.          if (var0 + var6 > -1 && var0 + var6 < 8) {
  111.             for(int var7 = -1; var7 < 2 && !var5; ++var7) {
  112.                if ((var6 != 0 || var7 != 0) && var1 + var7 > -1 && var1 + var7 < 8 && method_6(var2[var0 + var6][var1 + var7]) != var3) {
  113.                   var5 = append(var0, var1, (byte)(var0 + var6), (byte)(var1 + var7), var2, var4, false);
  114.                   System.out.println("Can king move X=" + var0 + " Y=" + var1 + " to X=" + (var0 + var6) + " Y=" + (var1 + var7) + " =" + var5);
  115.                }
  116.             }
  117.          }
  118.       }
  119.  
  120.       return var5;
  121.    }
  122.  
  123.    public static final boolean append(byte var0, byte var1, byte[][] var2, byte var3, byte var4, byte var5) {
  124.       return out(var0, var1, var2, var3, var4, var5) || arraycopy(var0, var1, var2, var3, var4, var5);
  125.    }
  126.  
  127.    public static final boolean arraycopy(byte var0, byte var1, byte[][] var2, byte var3, byte var4, byte var5) {
  128.       boolean var6 = false;
  129.  
  130.       for(int var7 = -1; var7 < 2 && !var6; ++var7) {
  131.          if (var7 != 0) {
  132.             if (var0 + var7 > -1 && var0 + var7 < 8 && method_6(var2[var0 + var7][var1]) != var3) {
  133.                var6 = out(var0, var1, (byte)(var0 + var7), var1, var2, var5, var4);
  134.             }
  135.  
  136.             if (!var6 && var1 + var7 > -1 && var1 + var7 < 8 && method_6(var2[var0][var1 + var7]) != var3) {
  137.                var6 = out(var0, var1, var0, (byte)(var1 + var7), var2, var5, var4);
  138.             }
  139.          }
  140.       }
  141.  
  142.       return var6;
  143.    }
  144.  
  145.    public static final boolean out(byte var0, byte var1, byte[][] var2, byte var3, byte var4, byte var5) {
  146.       boolean var6 = false;
  147.  
  148.       for(int var7 = -1; var7 < 2 && !var6; ++var7) {
  149.          if (var7 != 0 && var0 + var7 > -1 && var0 + var7 < 8) {
  150.             for(int var8 = -1; var8 < 2 && !var6; ++var8) {
  151.                if (var8 != 0 && var1 + var8 > -1 && var1 + var8 < 8 && method_6(var2[var0 + var7][var1 + var8]) != var3) {
  152.                   var6 = println(var0, var1, (byte)(var0 + var7), (byte)(var1 + var8), var2, var5, var4);
  153.                }
  154.             }
  155.          }
  156.       }
  157.  
  158.       return var6;
  159.    }
  160.  
  161.    public static final boolean println(byte var0, byte var1, byte[][] var2, byte var3, byte var4, byte var5) {
  162.       boolean var6 = false;
  163.       byte[][] var7 = new byte[][]{{-1, 1}, {-2, 2}};
  164.       int var8 = 0;
  165.       int var9 = 0;
  166.  
  167.       for(int var10 = 0; var10 < 2 && !var6; ++var10) {
  168.          for(int var11 = 0; var11 < 2 && !var6; ++var11) {
  169.             var8 = var0 + var7[0][var10];
  170.             var9 = var1 + var7[1][var11];
  171.             if (var8 > -1 && var8 < 8 && var9 > -1 && var9 < 8 && method_6(var2[var8][var9]) != var3) {
  172.                var6 = toString(var0, var1, (byte)var8, (byte)var9, var2, var5, var4);
  173.             }
  174.  
  175.             if (!var6) {
  176.                var8 = var0 + var7[1][var11];
  177.                var9 = var1 + var7[0][var10];
  178.                if (var8 > -1 && var8 < 8 && var9 > -1 && var9 < 8 && method_6(var2[var8][var9]) != var3) {
  179.                   var6 = toString(var0, var1, (byte)var8, (byte)var9, var2, var5, var4);
  180.                }
  181.             }
  182.          }
  183.       }
  184.  
  185.       return var6;
  186.    }
  187.  
  188.    public static final boolean toString(byte var0, byte var1, byte[][] var2, byte var3, byte var4, byte var5) {
  189.       boolean var6 = false;
  190.  
  191.       for(byte var7 = -1; var7 < 2 && !var6; ++var7) {
  192.          if (var0 + var7 > -1 && var0 + var7 < 8) {
  193.             var6 = abs(var0, var1, (byte)(var0 + var7), (byte)(var1 + var4), var2, var5, var4, var3);
  194.          }
  195.       }
  196.  
  197.       return var6;
  198.    }
  199.  
  200.    // $FF: renamed from: I (byte, byte, byte, byte[][], boolean, boolean[][]) boolean
  201.    public static final boolean method_2(byte var0, byte var1, byte var2, byte[][] var3, boolean var4, boolean[][] var5) {
  202.       int var6 = 0;
  203.       byte var7 = 0;
  204.       byte var8 = 0;
  205.       byte var9 = 0;
  206.       byte var10 = 0;
  207.       byte var11 = (byte)(var1 ^ 1);
  208.       boolean var12 = false;
  209.       byte var13 = println(var0);
  210.       byte var14 = abs(var0);
  211.       byte[][] var15 = new byte[][]{{-1, 1}, {-2, 2}};
  212.  
  213.       for(byte var16 = -1; var16 < 2 && (!var12 || var4); ++var16) {
  214.          for(byte var17 = -1; var17 < 2 && (!var12 || var4); ++var17) {
  215.             if (var16 != 0 || var17 != 0) {
  216.                var6 = abs(var0, var16, var17, var11, var3);
  217.                var7 = (byte)(var6 >> 8);
  218.                if (var7 != 0) {
  219.                   var8 = (byte)(var6 & 255);
  220.                   var9 = println(var8);
  221.                   var10 = abs(var8);
  222.                   switch (method_4(var7)) {
  223.                      case 1:
  224.                         var12 = append(var9, var10, var13, var14);
  225.                         if (var4 && var12) {
  226.                            arraycopy(var9, var10, var13, var14, var5);
  227.                         }
  228.                         break;
  229.                      case 2:
  230.                         var12 = arraycopy(var9, var10, var13, var14);
  231.                         if (var4 && var12) {
  232.                            arraycopy(var9, var10, var13, var14, var5);
  233.                         }
  234.                         break;
  235.                      case 3:
  236.                         var12 = out(var9, var10, var13, var14);
  237.                         if (var4 && var12) {
  238.                            arraycopy(var9, var10, var13, var14, var5);
  239.                         }
  240.                         break;
  241.                      case 4:
  242.                         var12 = println(var9, var10, var13, var14);
  243.                         if (var4 && var12) {
  244.                            arraycopy(var9, var10, var13, var14, var5);
  245.                         }
  246.                      case 5:
  247.                      default:
  248.                         break;
  249.                      case 6:
  250.                         var12 = toString(var9, var10, var13, var14, (byte)(-var2));
  251.                         if (var4 && var12) {
  252.                            arraycopy(var9, var10, var13, var14, var5);
  253.                         }
  254.                   }
  255.                }
  256.             }
  257.          }
  258.       }
  259.  
  260.       if (!var12 || var4) {
  261.          int var26 = 0;
  262.          int var18 = 0;
  263.  
  264.          for(int var19 = 0; var19 < 2 && !var12; ++var19) {
  265.             for(int var20 = 0; var20 < 2 && !var12; ++var20) {
  266.                var26 = var13 + var15[0][var19];
  267.                var18 = var14 + var15[1][var20];
  268.                if (var26 > -1 && var26 < 8 && var18 > -1 && var18 < 8 && method_4(var3[var26][var18]) == 5 && method_6(var3[var26][var18]) != var1) {
  269.                   if (var4) {
  270.                      var5[var26][var18] = true;
  271.                   }
  272.  
  273.                   var12 = true;
  274.                }
  275.  
  276.                if (!var12) {
  277.                   var26 = var13 + var15[1][var20];
  278.                   var18 = var14 + var15[0][var19];
  279.                   if (var26 > -1 && var26 < 8 && var18 > -1 && var18 < 8 && method_4(var3[var26][var18]) == 5 && method_6(var3[var26][var18]) != var1) {
  280.                      if (var4) {
  281.                         var5[var26][var18] = true;
  282.                      }
  283.  
  284.                      var12 = true;
  285.                   }
  286.                }
  287.             }
  288.          }
  289.       }
  290.  
  291.       return var12;
  292.    }
  293.  
  294.    private static int abs(byte var0, byte var1, byte var2, byte var3, byte[][] var4) {
  295.       byte var5 = println(var0);
  296.       byte var6 = abs(var0);
  297.       var5 = (byte)(var5 + var1);
  298.       var6 = (byte)(var6 + var2);
  299.       boolean var7 = false;
  300.  
  301.       byte var8;
  302.       for(var8 = 0; var5 > -1 && var5 < 8 && var6 > -1 && var6 < 8 && !var7; var6 += var2) {
  303.          var8 = var4[var5][var6];
  304.          var7 = method_4(var8) != 0;
  305.          var5 += var1;
  306.       }
  307.  
  308.       if (var7 && method_6(var8) == var3) {
  309.          var5 = (byte)(var5 - var1);
  310.          var6 = (byte)(var6 - var2);
  311.          return method_4(var8) << 8 | method_11(var5, var6);
  312.       } else {
  313.          return 0;
  314.       }
  315.    }
  316.  
  317.    // $FF: renamed from: I (byte, byte, byte, byte, byte[][], byte, byte, boolean) boolean
  318.    public static final boolean method_3(byte var0, byte var1, byte var2, byte var3, byte[][] var4, byte var5, byte var6, boolean var7) {
  319.       boolean var8 = false;
  320.       byte var9 = var4[var0][var1];
  321.       byte var10 = method_6(var9);
  322.       byte var11 = method_4(var9);
  323.       switch (var11) {
  324.          case 1:
  325.             var8 = append(var0, var1, var2, var3, var4, var6, var7);
  326.             break;
  327.          case 2:
  328.             var8 = arraycopy(var0, var1, var2, var3, var4, var5, var6);
  329.             break;
  330.          case 3:
  331.             var8 = out(var0, var1, var2, var3, var4, var5, var6);
  332.             break;
  333.          case 4:
  334.             var8 = println(var0, var1, var2, var3, var4, var5, var6);
  335.             break;
  336.          case 5:
  337.             var8 = toString(var0, var1, var2, var3, var4, var5, var6);
  338.             break;
  339.          case 6:
  340.             var8 = abs(var0, var1, var2, var3, var4, var5, var6, var10);
  341.       }
  342.  
  343.       return var8;
  344.    }
  345.  
  346.    public static final boolean append(byte var0, byte var1, byte var2, byte var3, byte[][] var4, byte var5, boolean var6) {
  347.       int var7 = var2 - var0;
  348.       int var8 = Math.abs(var7);
  349.       int var9 = Math.abs(var3 - var1);
  350.       boolean var10 = false;
  351.       byte[][] var11 = new byte[8][8];
  352.       if (var8 < 2 && var9 < 2) {
  353.          append(var4, var11);
  354.          var10 = true;
  355.       } else if (var8 == 2 && var9 == 0 && out(var4[var0][var1]) == 0) {
  356.          int var12 = var7 > 0 ? 7 : 0;
  357.          byte var13 = var4[var12][var1];
  358.          if (!var6 && method_4(var13) == 3 && out(var13) == 0 && append(var0, var1, (byte)var12, var1, var4)) {
  359.             append(var4, var11);
  360.             int var14 = append(var0, var2);
  361.             var10 = true;
  362.  
  363.             for(int var15 = 0; var15 < 2 && var10; ++var15) {
  364.                arraycopy(var0, var1, (byte)(var0 + var14), var3, var11);
  365.                if (method_2(method_11((byte)(var0 + var14), var3), method_6(var4[var0][var1]), var5, var11, false, (boolean[][])null)) {
  366.                   var10 = false;
  367.                }
  368.  
  369.                arraycopy((byte)(var0 + var14), var3, var0, var1, var11);
  370.                var14 <<= 1;
  371.             }
  372.  
  373.             if (var10) {
  374.                arraycopy((byte)var12, var1, (byte)(var2 - append(var0, var2)), var1, (byte[][])var11);
  375.             }
  376.          }
  377.       }
  378.  
  379.       if (var10) {
  380.          arraycopy(var0, var1, var2, var3, var11);
  381.          if (!method_2(method_11(var2, var3), method_6(var11[var2][var3]), var5, var11, false, (boolean[][])null)) {
  382.             append(var11, var4);
  383.          } else {
  384.             var10 = false;
  385.          }
  386.       }
  387.  
  388.       return var10;
  389.    }
  390.  
  391.    public static final boolean arraycopy(byte var0, byte var1, byte var2, byte var3, byte[][] var4, byte var5, byte var6) {
  392.       return println(var0, var1, var2, var3, var4, var5, var6) || out(var0, var1, var2, var3, var4, var5, var6);
  393.    }
  394.  
  395.    public static final boolean out(byte var0, byte var1, byte var2, byte var3, byte[][] var4, byte var5, byte var6) {
  396.       int var7 = var2 - var0;
  397.       int var8 = var3 - var1;
  398.       boolean var9 = false;
  399.       byte[][] var10 = new byte[8][8];
  400.       if ((var7 == 0 || var8 == 0) && append(var0, var1, var2, var3, var4)) {
  401.          append(var4, var10);
  402.          arraycopy(var0, var1, var2, var3, var10);
  403.          if (!method_2(var5, method_6(var4[var0][var1]), var6, var10, false, (boolean[][])null)) {
  404.             append(var10, var4);
  405.             var9 = true;
  406.          }
  407.       }
  408.  
  409.       return var9;
  410.    }
  411.  
  412.    public static final boolean println(byte var0, byte var1, byte var2, byte var3, byte[][] var4, byte var5, byte var6) {
  413.       int var7 = Math.abs(var2 - var0);
  414.       int var8 = Math.abs(var3 - var1);
  415.       boolean var9 = false;
  416.       byte[][] var10 = new byte[8][8];
  417.       if (var7 == var8 && append(var0, var1, var2, var3, var4)) {
  418.          append(var4, var10);
  419.          arraycopy(var0, var1, var2, var3, var10);
  420.          if (!method_2(var5, method_6(var4[var0][var1]), var6, var10, false, (boolean[][])null)) {
  421.             append(var10, var4);
  422.             var9 = true;
  423.          }
  424.       }
  425.  
  426.       return var9;
  427.    }
  428.  
  429.    public static final boolean toString(byte var0, byte var1, byte var2, byte var3, byte[][] var4, byte var5, byte var6) {
  430.       int var7 = Math.abs(var2 - var0);
  431.       int var8 = Math.abs(var3 - var1);
  432.       boolean var9 = false;
  433.       byte[][] var10 = new byte[8][8];
  434.       if (var7 == 1 && var8 == 2 || var7 == 2 && var8 == 1) {
  435.          append(var4, var10);
  436.          arraycopy(var0, var1, var2, var3, var10);
  437.          if (!method_2(var5, method_6(var4[var0][var1]), var6, var10, false, (boolean[][])null)) {
  438.             append(var10, var4);
  439.             var9 = true;
  440.          }
  441.       }
  442.  
  443.       return var9;
  444.    }
  445.  
  446.    public static final boolean abs(byte var0, byte var1, byte var2, byte var3, byte[][] var4, byte var5, byte var6, byte var7) {
  447.       int var8 = var2 - var0;
  448.       int var9 = Math.abs(var8);
  449.       int var10 = var3 - var1;
  450.       boolean var11 = false;
  451.       byte var12 = 0;
  452.       byte var13 = var4[var2][var1];
  453.       byte[][] var14 = new byte[8][8];
  454.       if (method_4(var4[var2][var3]) == 0) {
  455.          if (var9 == 0) {
  456.             if (var10 == var6) {
  457.                append(var4, var14);
  458.                var11 = true;
  459.             } else if (var10 == var6 * 2 && out(var4[var0][var1]) == 0 && method_4(var4[var0][(byte)(var1 + var6)]) == 0) {
  460.                var12 = 1;
  461.                append(var4, var14);
  462.                var11 = true;
  463.             }
  464.          } else if (method_4(var13) == 6 && method_6(var13) != var7 && toString(var13) == 1) {
  465.             append(var4, var14);
  466.             var14[var2][var1] = 0;
  467.             var11 = true;
  468.          }
  469.       } else if (var10 == var6 && var9 == 1) {
  470.          append(var4, var14);
  471.          var11 = true;
  472.       }
  473.  
  474.       if (var11) {
  475.          arraycopy(var0, var1, var2, var3, var14);
  476.          var14[var2][var3] = abs(var14[var2][var3], var12);
  477.          if (!method_2(var5, var7, var6, var14, false, (boolean[][])null)) {
  478.             append(var14, var4);
  479.             var11 = true;
  480.          } else {
  481.             var11 = false;
  482.          }
  483.       }
  484.  
  485.       return var11;
  486.    }
  487.  
  488.    public static final boolean append(byte var0, byte var1, byte var2, byte var3) {
  489.       int var4 = Math.abs(var2 - var0);
  490.       int var5 = Math.abs(var3 - var1);
  491.       boolean var6 = false;
  492.       if (var4 < 2 && var5 < 2) {
  493.          var6 = true;
  494.       }
  495.  
  496.       return var6;
  497.    }
  498.  
  499.    public static final boolean arraycopy(byte var0, byte var1, byte var2, byte var3) {
  500.       return println(var0, var1, var2, var3) || out(var0, var1, var2, var3);
  501.    }
  502.  
  503.    public static final boolean out(byte var0, byte var1, byte var2, byte var3) {
  504.       int var4 = var2 - var0;
  505.       int var5 = var3 - var1;
  506.       boolean var6 = false;
  507.       if (var4 == 0 || var5 == 0) {
  508.          var6 = true;
  509.       }
  510.  
  511.       return var6;
  512.    }
  513.  
  514.    public static final boolean println(byte var0, byte var1, byte var2, byte var3) {
  515.       int var4 = Math.abs(var2 - var0);
  516.       int var5 = Math.abs(var3 - var1);
  517.       boolean var6 = false;
  518.       if (var4 == var5) {
  519.          var6 = true;
  520.       }
  521.  
  522.       return var6;
  523.    }
  524.  
  525.    public static final boolean toString(byte var0, byte var1, byte var2, byte var3, byte var4) {
  526.       int var5 = Math.abs(var2 - var0);
  527.       int var6 = var3 - var1;
  528.       boolean var7 = false;
  529.       if (var5 == 1 && var6 == var4) {
  530.          var7 = true;
  531.       }
  532.  
  533.       return var7;
  534.    }
  535.  
  536.    public static final boolean append(byte var0, byte var1, byte var2, byte var3, byte[][] var4) {
  537.       byte var5 = (byte)append(var0, var2);
  538.       byte var6 = (byte)append(var1, var3);
  539.       boolean var7 = false;
  540.       var0 = (byte)(var0 + var5);
  541.  
  542.       for(byte var9 = (byte)(var1 + var6); (var0 != var2 || var9 != var3) && !var7; var9 += var6) {
  543.          var7 = method_4(var4[var0][var9]) != 0;
  544.          var0 += var5;
  545.       }
  546.  
  547.       return !var7;
  548.    }
  549.  
  550.    public static final void arraycopy(byte var0, byte var1, byte var2, byte var3, byte[][] var4) {
  551.       var4[var2][var3] = method_9(println(var4[var0][var1], 1), 0);
  552.       var4[var0][var1] = method_9((byte)0, 0);
  553.    }
  554.  
  555.    // $FF: renamed from: I (byte) byte
  556.    public static final byte method_4(byte var0) {
  557.       return (byte)(var0 & 7);
  558.    }
  559.  
  560.    // $FF: renamed from: I (byte, byte) byte
  561.    public static final byte method_5(byte var0, byte var1) {
  562.       var0 = (byte)(var0 & 120);
  563.       return (byte)(var0 | var1);
  564.    }
  565.  
  566.    // $FF: renamed from: Z (byte) byte
  567.    public static final byte method_6(byte var0) {
  568.       return (byte)(var0 >> 6 & 1);
  569.    }
  570.  
  571.    // $FF: renamed from: I (byte, int) byte
  572.    public static final byte method_7(byte var0, int var1) {
  573.       var0 = (byte)(var0 & 63);
  574.       return (byte)(var0 | var1 << 6);
  575.    }
  576.  
  577.    // $FF: renamed from: C (byte) byte
  578.    public static final byte method_8(byte var0) {
  579.       return (byte)(var0 >> 3 & 1);
  580.    }
  581.  
  582.    // $FF: renamed from: Z (byte, int) byte
  583.    public static final byte method_9(byte var0, int var1) {
  584.       var0 = (byte)(var0 & 119);
  585.       return (byte)(var0 | var1 << 3);
  586.    }
  587.  
  588.    public static final int out(byte var0) {
  589.       return (byte)(var0 >> 4 & 1);
  590.    }
  591.  
  592.    public static final byte println(byte var0, int var1) {
  593.       var0 = (byte)(var0 & 111);
  594.       return (byte)(var0 | var1 << 4);
  595.    }
  596.  
  597.    public static final int toString(byte var0) {
  598.       return (byte)(var0 >> 5 & 1);
  599.    }
  600.  
  601.    public static final byte abs(byte var0, int var1) {
  602.       var0 = (byte)(var0 & 95);
  603.       return (byte)(var0 | var1 << 5);
  604.    }
  605.  
  606.    public static final int append(byte var0, byte var1) {
  607.       return var0 == var1 ? 0 : (var0 < var1 ? 1 : -1);
  608.    }
  609.  
  610.    // $FF: renamed from: I (byte[][], byte) void
  611.    public static final void method_10(byte[][] var0, byte var1) {
  612.       byte var2 = (byte)(var1 ^ 1);
  613.  
  614.       for(int var3 = 0; var3 < var0.length; ++var3) {
  615.          for(int var4 = 0; var4 < var0[var3].length; ++var4) {
  616.             byte var5 = var0[var3][var4];
  617.             if (method_6(var5) == var2 && method_4(var5) == 6 && toString(var5) == 1) {
  618.                var0[var3][var4] = abs(var5, 0);
  619.             }
  620.          }
  621.       }
  622.  
  623.    }
  624.  
  625.    private static void arraycopy(byte var0, byte var1, byte var2, byte var3, boolean[][] var4) {
  626.       int var5 = append(var0, var2);
  627.  
  628.       for(int var6 = append(var1, var3); var0 != var2 || var1 != var3; var1 = (byte)(var1 + var6)) {
  629.          var4[var0][var1] = true;
  630.          var0 = (byte)(var0 + var5);
  631.       }
  632.  
  633.    }
  634.  
  635.    // $FF: renamed from: Z (byte, byte) byte
  636.    public static final byte method_11(byte var0, byte var1) {
  637.       return (byte)(var0 << 3 | var1);
  638.    }
  639.  
  640.    public static final byte println(byte var0) {
  641.       return (byte)(var0 >> 3);
  642.    }
  643.  
  644.    public static final byte abs(byte var0) {
  645.       return (byte)(var0 & 7);
  646.    }
  647.  
  648.    private static void append(byte[][] var0, byte[][] var1) {
  649.       for(int var2 = 0; var2 < 8; ++var2) {
  650.          System.arraycopy(var0[var2], 0, var1[var2], 0, 8);
  651.       }
  652.  
  653.    }
  654. }
  655.